package com.szosen.measurement;

import com.szosen.util.StringUtils;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.TreeMap;

@SuppressWarnings("unused")
public class UploadECGBean {

	/**
	 * 文件头： （共 12 个字节）0XFF,0X00,0XBB,0X44,'A','S','E','C','G','F','I','L
	 */
	private byte[] head12 = new byte[12];
	/**
	 * 参数信息： （共 24 个字节
	 */
	private byte[] info24 = new byte[24];
	/**
	 * 病人信息（共 164 个字节
	 */
	private byte[] people164 = new byte[164];
	/**
	 * 代表心博数据（共 2048*12=24576 个字节）
	 */
	private ArrayList<byte[]> ecgdataLv12 = new ArrayList<byte[]>();
	/**
	 * 波形数据（共 20480*12=245760 个字节）
	 */
	private ArrayList<byte[]> ecgdata12 = new ArrayList<byte[]>();
	/**
	 * 报告 1 数据(36) XX,XX(2 个了字节 心率, 16 位无符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 PR_间期, 16 位无符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 QRS_时限，16 位无符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 QT_间期，16 位无符号数，高位在前，低位在后）<br>
	 * XX,XX(2 个了字节 QTC_间期，16 位无符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 P_电轴，16 位有符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 QRS_电轴，16 位有符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 T_电轴，16 位有符号数，高位在前，低位在后） <br>
	 * XX,XX(2 个了字节 RV5_电压，16 位有符号数，高位在前，低位在后）<br>
	 * XX,XX(2 个了字节 SV1_电压，16 位有符号数，高位在前，低位在后
	 */
	private byte[] report1 = new byte[36];
	/**
	 * 报告 2 数据（共 2052 字节）
	 */
	private byte[] report2 = new byte[2052];
	/**
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，P 波起点，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，P 波终点，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，Q 波起点，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，Q 波终点，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，T 波终点，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，QRS 心拍，单位个）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，QRS 宽度，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，QT 波宽度，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，QTc，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，ST(J)波终点，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，P 波宽度，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，PRFORQTc 波宽度，单位 MS）<br>
	 * XX-XX(8 个字节，保留）<br>
	 */
	private byte[] report3 = new byte[32];
	/***
	 * 一共有12个导联数据， XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 P 电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 Q 波电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 Q 波宽度，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 R 波电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 R 波宽度，单位 MS）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 ST J 点电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 ST 中点电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 ST 终点电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 T 波电压，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 T 波电压最大值，单位 UV）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，I 导 P 波电压最大值，单位 UV）<br>
	 * XX-XX(10 个字节，保留）
	 */
	private byte[] report4 = new byte[384];
	/***
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第一个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第二个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第三个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第四个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第五个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第六个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第七个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第八个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第九个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第十个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第十一个 R 波位置，偏移点）<br>
	 * XX-XX(2 个字节，高位在前，低位在后，16 位数，第十二个 R 波位置，偏移点）<br>
	 * XX-XX(8 个字节，保留）
	 */
	private byte[] report5 = new byte[32];
	/**
	 * 保留字节数据（共 64 ）
	 */
	private byte[] baoliu = new byte[64];
	/**
	 * 结束符号。6个。0XCC,0X33,0XAA,0X55,0X0D,0X0A
	 */
	private byte[] end = new byte[6];

	public UploadECGBean(byte[] ecgData) {
		// System.out.println("UploadECGBean.byte[]长度：" + ecgData.length);
		int index = 0;
		System.arraycopy(ecgData, index, head12, 0, head12.length);
		index += head12.length;
		System.arraycopy(ecgData, index, info24, 0, info24.length);
		index += info24.length;
		System.arraycopy(ecgData, index, people164, 0, people164.length);
		index += people164.length;
		// System.out.println("uploadecgbean的。people164后面index的长度是：" + index);
		for (int i = 0; i < 12; i++) {
			byte[] temp = new byte[2048];
			System.arraycopy(ecgData, index, temp, 0, temp.length);
			ecgdataLv12.add(temp);
			index += temp.length;
		}
		for (int i = 0; i < 12; i++) {
			byte[] temp = new byte[20480];
			System.arraycopy(ecgData, index, temp, 0, temp.length);
			ecgdata12.add(temp);
			index += temp.length;
		}
		// System.out.println("uploadecgbean的。心电data后面index的长度是：" + index);
		System.arraycopy(ecgData, index, report1, 0, report1.length);
		index += report1.length;
		System.arraycopy(ecgData, index, report2, 0, report2.length);
		index += report2.length;
		System.arraycopy(ecgData, index, report3, 0, report3.length);
		index += report3.length;
		System.arraycopy(ecgData, index, report4, 0, report4.length);
		index += report4.length;
		System.arraycopy(ecgData, index, report5, 0, report5.length);
		index += report5.length;
		System.arraycopy(ecgData, index, baoliu, 0, baoliu.length);
		index += baoliu.length;
		System.arraycopy(ecgData, index, end, 0, end.length);
		index += end.length;
		// System.out.println("uploadecgbean的。最后index的长度是：" + index);
		// System.out.println("报告3"+Arrays.toString(this.getReport3()));
		// System.out.println("报告5"+Arrays.toString(this.getReport5()));
		ArrayList<int[]> baoGao4 = this.getReport4();
		for (int i = 0; i < baoGao4.size(); i++) {
			int[] temp = baoGao4.get(i);
			// System.out.println("报告4的导联"+i+"为："+Arrays.toString(temp));
		}
		// FileSaveUtil.saveTxtFile("导联uploadbean", "uploadbean",
		// StringUtils.ByteArrToHex(ecgData));
		// System.out.println(StringUtils.ByteArrToHex(end));
	}

	/**
	 * 保留count个数据的集合
	 *
	 * @param src
	 * @param count
	 * @return
	 */
	public static ArrayList<int[]> getLengthData(ArrayList<int[]> src, int count) {
		ArrayList<int[]> result = new ArrayList<int[]>();
		int[] temp = null;
		for (int i = 0; i < src.size(); i++) {
			temp = getCountInts(src.get(i), count);
			result.add(temp);
		}
		return result;
	}

	/**
	 * 将int[]保留count个数据。返回
	 *
	 * @param src
	 * @param count
	 * @return
	 */
	public static int[] getCountInts(int[] src, int count) {
		int[] result = new int[count];
		System.arraycopy(src, 0, result, 0, count);
		return result;
	}

	/***
	 * 切割一个数组，每n个点获取一个元素
	 */
	public static ArrayList<int[]> getSplitArray(ArrayList<int[]> src, int n) {
		ArrayList<int[]> result = new ArrayList<int[]>();
		for (int i = 0; i < src.size(); i++) {
			int[] temp = getSplitInts(src.get(i), n);
			result.add(temp);
		}
		return result;
	}

	/** 每n个点取一个数字，然后返回int数组 */
	public static int[] getMeiNgeQushu(int[] src, int n) {
		int[] result = new int[src.length / n];
		for (int i = 0; i < result.length; i++) {
			result[i] = src[i * n];
		}
		return result;
	}

	/***
	 * 每n数获取一个点。，返回集合。
	 *
	 * @param src
	 * @param n
	 * @return
	 */
	public static ArrayList<int[]> getMeiGeShuArray(ArrayList<int[]> src, int n) {
		ArrayList<int[]> result = new ArrayList<int[]>();
		for (int i = 0; i < src.size(); i++) {
			int[] s = src.get(i);
			int[] temp = getMeiNgeQushu(s, n);
			result.add(temp);
		}
		return result;
	}

	public static int[] getSplitInts(int[] src, int n) {
		int[] result = new int[src.length / n];
		for (int i = 0; i < result.length; i++) {
			result[i] = getpingjun(src, i, i * n);
		}
		return result;
	}

	/***
	 * 获取几个数的平均数。
	 *
	 * @param src
	 * @param a
	 *            开始的数的角标
	 * @param b
	 *            包括的数的角标
	 * @return
	 */
	public static int getpingjun(int[] src, int a, int b) {
		int result = 0;
		int count = 0;
		for (int i = a; i <= b; i++) {
			count += src[i];
		}
		return count / (b - a + 1);
	}

	/***
	 * 获取心电12导的集合数据。
	 *
	 * @return
	 */
	public ArrayList<int[]> getECG12() {
		ArrayList<int[]> result = new ArrayList<>();
		for (int i = 0; i < ecgdata12.size(); i++) {
			byte[] temp = ecgdata12.get(i);
			int[] data = StringUtils.ByteArray2IntArray(temp);
			result.add(data);
		}
		return result;
	}

	public ArrayList<int[]> getECGLV12() {
		ArrayList<int[]> result = new ArrayList<>();
		for (int i = 0; i < ecgdataLv12.size(); i++) {
			byte[] temp = ecgdataLv12.get(i);
			int[] data = StringUtils.ByteArray2IntArray(temp);
			result.add(data);
		}
		return result;
	}

	public String getXinLv() {
		return "" + StringUtils.byte2intUnsigned(report1[0], report1[1]);
	}

	/**
	 * 获取报告1
	 *
	 * @return 返回一个treemap集合。
	 * */
	public TreeMap<String, Integer> getReport1() {
		TreeMap<String, Integer> result = new TreeMap<String, Integer>();
		result.put("心率", StringUtils.byte2intUnsigned(report1[0], report1[1]));
		result.put("PR_间期",
				StringUtils.byte2intUnsigned(report1[2], report1[3]));
		result.put("QRS_时限",
				StringUtils.byte2intUnsigned(report1[4], report1[5]));
		result.put("QT_间期",
				StringUtils.byte2intUnsigned(report1[6], report1[7]));
		result.put("QTC_间期",
				StringUtils.byte2intUnsigned(report1[8], report1[9]));
		result.put("P_电轴", StringUtils.byte2int(report1[10], report1[11]));
		result.put("QRS_电轴", StringUtils.byte2int(report1[12], report1[13]));
		result.put("T_电轴", StringUtils.byte2int(report1[14], report1[15]));
		result.put("RV5_电压", StringUtils.byte2int(report1[16], report1[17]));
		result.put("SV1_电压", StringUtils.byte2int(report1[18], report1[19]));
		return result;
	}

	/***
	 * 获取报告1，返回int[]数组，里面放的是int类型
	 * @return int[]
	 */
	public int[] getReport1IntArray() {
		int[] result = new int[10];
		result[0] = StringUtils.byte2intUnsigned(report1[0], report1[1]);
		result[1] = StringUtils.byte2intUnsigned(report1[2], report1[3]);
		result[2] = StringUtils.byte2intUnsigned(report1[4], report1[5]);
		result[3] = StringUtils.byte2intUnsigned(report1[6], report1[7]);
		result[4] = StringUtils.byte2intUnsigned(report1[8], report1[9]);
		result[5] = StringUtils.byte2int(report1[10], report1[11]);
		result[6] = StringUtils.byte2int(report1[12], report1[13]);
		result[7] = StringUtils.byte2int(report1[14], report1[15]);
		result[8] = StringUtils.byte2int(report1[16], report1[17]);
		result[9] = StringUtils.byte2int(report1[18], report1[19]);
		return result;
	}

	/**
	 * 获取报告2
	 *
	 * @return
	 */
	public String getReport2() {
		byte[] numberBytes = new byte[4];
		for (int i = 0; i < 4; i++) {
			numberBytes[i] = report2[i];
		}
		String reportNumber = StringUtils.ByteArrToHex(numberBytes).trim();
		int number = Integer.valueOf(reportNumber.substring(
				reportNumber.length() - 2, reportNumber.length()));
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < number; i++) {
			byte[] data = new byte[256];
			System.arraycopy(report2, 0 + 4 + i * 256, data, 0, 256);
			int index;
			String s = "";
			try {
				if (remove00(data) != null) {
					s = new String(remove00(data), "gbk").trim();
				}
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
			sb.append(s + "\n");
		}
		String result = "";
		result = sb.toString().trim();
		result.replace("*", "");
		return result;
	}

	public int[] getReport3() {
		int[] result = new int[12];
		for (int i = 0; i < result.length; i++) {
			result[i] = StringUtils
					.byte2int(report3[2 * i], report3[2 * i + 1]);
		}
		return result;
	}

	public ArrayList<int[]> getReport4() {
		ArrayList<int[]> result = new ArrayList<int[]>();
		for (int j = 0; j < 12; j++) {
			int[] temp = new int[11];
			for (int i = 0; i < temp.length; i++) {
				temp[i] = StringUtils.byte2int(report4[j * 32 + 2 * i],
						report4[j * 32 + 1 + 2 * i]);
			}
			result.add(temp);
		}
		return result;
	}

	public int[] getReport5() {
		int[] result = new int[12];
		for (int i = 0; i < result.length; i++) {
			result[i] = StringUtils
					.byte2int(report5[2 * i], report5[2 * i + 1]);
		}
		return result;
	}

	private byte[] remove00(byte[] data) {
		byte[] result = null;
		for (int j = 0; j < data.length; j++) {
			String s = StringUtils.Byte2Hex(data[j]);
			if (s.contains("00")) {
				result = new byte[j];
				System.arraycopy(data, 0, result, 0, j);
				return result;
			}
		}
		return result;
	}
}
